{"version":3,"file":"actjs.esm.js","sources":["../src/signal.ts","../src/global-signal.ts","../src/context.ts","../src/lifecycle.ts","../src/head.ts","../src/resource.ts","../src/template.ts","../src/component-registry.ts","../src/diff.ts","../src/scheduler.ts","../src/component.ts","../src/css.ts","../src/timers.ts","../src/app.ts","../src/router.ts","../src/loader.ts"],"sourcesContent":["import type { Effect, Signal } from './types.js';\n\n// The currently-executing Effect (render fn or computed). null = not tracking.\nlet currentObserver: Effect | null = null;\n\n// ─── Batch ────────────────────────────────────────────────────────────────────\n\nlet batchDepth = 0;\nconst pendingEffects = new Set<Effect>();\n\n/**\n * Run multiple signal writes as a single atomic update.\n * All effects and renders triggered inside fn() are deferred until the batch\n * completes, so each subscriber fires at most once.\n *\n * @example\n * batch(() => {\n *   setPrice(newPrice);    // ← would each trigger a render separately\n *   setVolume(newVolume);  // ← now both are coalesced into one render\n * });\n */\nexport function batch(fn: () => void): void {\n  batchDepth++;\n  try {\n    fn();\n  } finally {\n    batchDepth--;\n    if (batchDepth === 0) {\n      // Drain pending effects — snapshot first so mutations during run are safe\n      const toRun = [...pendingEffects];\n      pendingEffects.clear();\n      for (const eff of toRun) eff.run();\n    }\n  }\n}\n\nexport function setCurrentObserver(observer: Effect | null): void {\n  currentObserver = observer;\n}\n\nexport function getCurrentObserver(): Effect | null {\n  return currentObserver;\n}\n\nexport interface SignalOptions<T> {\n  /**\n   * Custom equality function. If it returns true the setter is a no-op and\n   * no subscribers are notified.\n   * Pass `false` to disable equality checks entirely (always notify).\n   *\n   * @default Object.is\n   * @example\n   * // Deep-equal arrays — only re-render when contents actually change\n   * const [items, setItems] = signal([], { equals: (a, b) => JSON.stringify(a) === JSON.stringify(b) });\n   *\n   * // Always notify (useful for objects mutated in place)\n   * const [state, setState] = signal(obj, { equals: false });\n   */\n  equals?: ((a: T, b: T) => boolean) | false;\n}\n\n/**\n * Fine-grained signal. Calling getter() inside a tracking context\n * auto-subscribes the observer to this signal.\n *\n * @example\n * const [count, setCount] = signal(0);\n * setCount(1);               // set directly\n * setCount(n => n + 1);      // updater function\n * console.log(count());      // 2\n */\nexport function signal<T>(initialValue: T, options?: SignalOptions<T>): Signal<T> {\n  let value = initialValue;\n  const subscribers: Set<Effect> = new Set();\n  const equalsFn: ((a: T, b: T) => boolean) | false =\n    options?.equals === false ? false : (options?.equals ?? Object.is);\n\n  const getter = (): T => {\n    if (currentObserver !== null) {\n      subscribers.add(currentObserver);\n      currentObserver.deps.add(subscribers);\n    }\n    return value;\n  };\n\n  const setter = (newValue: T | ((prev: T) => T)): void => {\n    const next =\n      typeof newValue === 'function'\n        ? (newValue as (prev: T) => T)(value)\n        : newValue;\n\n    if (equalsFn !== false && equalsFn(next, value)) return;\n    value = next;\n\n    // Snapshot subscribers before notifying — effects may add/remove during run\n    for (const effect of [...subscribers]) {\n      if (batchDepth > 0) {\n        pendingEffects.add(effect);\n      } else {\n        effect.run();\n      }\n    }\n  };\n\n  return [getter, setter];\n}\n\n/**\n * Derived signal. Lazily re-computes when any tracked dependency changes.\n * Reading computed() inside a tracking context also subscribes the observer\n * to this computed's upstream dependencies.\n *\n * @example\n * const [first, setFirst] = signal('Ada');\n * const [last,  setLast]  = signal('Lovelace');\n * const full = computed(() => `${first()} ${last()}`);\n * console.log(full()); // 'Ada Lovelace'\n * setFirst('Grace');\n * console.log(full()); // 'Grace Lovelace'\n */\nexport function computed<T>(fn: () => T): () => T {\n  let cachedValue: T;\n  let dirty = true;\n\n  // The effect that re-runs fn when dependencies change\n  const effect: Effect = {\n    deps: new Set(),\n    run() {\n      // Clean up previous subscriptions\n      for (const dep of effect.deps) {\n        dep.delete(effect);\n      }\n      effect.deps.clear();\n      dirty = true;\n      // Notify any observers of this computed\n      for (const sub of [...computedSubscribers]) {\n        sub.run();\n      }\n    },\n  };\n\n  const computedSubscribers: Set<Effect> = new Set();\n\n  const getter = (): T => {\n    // Subscribe current outer observer to this computed's output\n    if (currentObserver !== null) {\n      computedSubscribers.add(currentObserver);\n      currentObserver.deps.add(computedSubscribers);\n    }\n\n    if (dirty) {\n      // Run fn inside our own tracking context to collect deps\n      const prev = currentObserver;\n      currentObserver = effect;\n      try {\n        cachedValue = fn();\n      } finally {\n        currentObserver = prev;\n      }\n      dirty = false;\n    }\n\n    return cachedValue as T;\n  };\n\n  return getter;\n}\n","import { signal } from './signal.js';\nimport type { Signal } from './types.js';\n\nconst registry = new Map<string, Signal<unknown>>();\n\n/**\n * Global keyed signal — same [getter, setter] pair for every caller using\n * the same key. Designed for IIFE/script-tag users who can't share module scope.\n * For module-based projects, prefer exporting a signal directly.\n */\nexport function globalSignal<T>(key: string, initialValue: T): Signal<T> {\n  if (!registry.has(key)) {\n    registry.set(key, signal(initialValue) as Signal<unknown>);\n  }\n  return registry.get(key) as Signal<T>;\n}\n\n/** Clears the global registry — useful for test isolation. */\nexport function _clearGlobalSignals(): void {\n  registry.clear();\n}\n","import type { SetupContext } from './types.js';\n\n/** The currently-active component setup context. null = not inside setup(). */\nlet currentSetup: SetupContext | null = null;\n\nexport function getCurrentSetup(): SetupContext | null {\n  return currentSetup;\n}\n\nexport function setCurrentSetup(ctx: SetupContext | null): void {\n  currentSetup = ctx;\n}\n\nexport function createSetupContext(): SetupContext {\n  return {\n    onInitFns: [],\n    onMountFns: [],\n    onDestroyFns: [],\n    headConfig: null,\n  };\n}\n","import { getCurrentSetup } from './context.js';\nimport { setCurrentObserver, getCurrentObserver } from './signal.js';\nimport type { Effect } from './types.js';\n\nfunction assertInSetup(hookName: string): ReturnType<typeof getCurrentSetup> & object {\n  const ctx = getCurrentSetup();\n  if (!ctx) {\n    throw new Error(`${hookName}() must be called inside a component setup function.`);\n  }\n  return ctx;\n}\n\n/**\n * Runs on BOTH server (SSR) and client — safe for data loading, initial state setup.\n * Call async operations here; executes before onMount.\n */\nexport function onInit(fn: () => void | Promise<void>): void {\n  const ctx = assertInSetup('onInit');\n  ctx.onInitFns.push(fn);\n}\n\n/**\n * Runs on CLIENT ONLY after first render — DOM is available.\n * Never called during SSR.\n */\nexport function onMount(fn: () => void): void {\n  const ctx = assertInSetup('onMount');\n  ctx.onMountFns.push(fn);\n}\n\n/**\n * Runs on CLIENT ONLY when component is removed / app.destroy() called.\n * Never called during SSR.\n */\nexport function onDestroy(fn: () => void): void {\n  const ctx = assertInSetup('onDestroy');\n  ctx.onDestroyFns.push(fn);\n}\n\n/**\n * Reactive side effect. Runs immediately and re-runs whenever any signal read\n * inside fn() changes. Returns a dispose function that stops the effect.\n *\n * When called inside a component setup, the effect is automatically disposed\n * when the component is destroyed — no manual cleanup needed.\n *\n * @example\n * // Inside a component — auto-cleaned on destroy\n * effect(() => {\n *   chart.setData(prices()); // re-runs whenever prices changes\n * });\n *\n * // Standalone — dispose manually\n * const stop = effect(() => console.log('count:', count()));\n * stop(); // unsubscribe\n *\n * // With cleanup\n * effect(() => {\n *   const sub = store.subscribe(handler);\n *   return () => sub.unsubscribe(); // called before next run and on dispose\n * });\n */\nexport function effect(fn: () => void | (() => void)): () => void {\n  let cleanup: (() => void) | void;\n  let running = false;\n\n  const eff: Effect = {\n    deps: new Set(),\n    run() {\n      if (running) return; // re-entry guard — prevents infinite loops\n      running = true;\n      // Clean up previous signal subscriptions\n      for (const dep of eff.deps) dep.delete(eff);\n      eff.deps.clear();\n      // Run cleanup returned by previous execution\n      if (typeof cleanup === 'function') { cleanup(); cleanup = undefined; }\n      // Run fn inside a tracking context to collect new deps\n      const prev = getCurrentObserver();\n      setCurrentObserver(eff);\n      try {\n        cleanup = fn();\n      } finally {\n        setCurrentObserver(prev);\n        running = false;\n      }\n    },\n  };\n\n  function dispose(): void {\n    for (const dep of eff.deps) dep.delete(eff);\n    eff.deps.clear();\n    if (typeof cleanup === 'function') { cleanup(); cleanup = undefined; }\n  }\n\n  // Inside a component setup — auto-dispose when the component is destroyed\n  const ctx = getCurrentSetup();\n  if (ctx) {\n    ctx.onDestroyFns.push(dispose);\n  }\n\n  // Run immediately to establish the initial subscription\n  eff.run();\n\n  return dispose;\n}\n\n/**\n * Starts a repeating interval when the component mounts and clears it\n * automatically when the component is destroyed. Client-only.\n *\n * @example\n * useInterval(() => setTick(t => t + 1), 1000);\n */\nexport function useInterval(fn: () => void, ms: number): void {\n  const ctx = assertInSetup('useInterval');\n  let id: ReturnType<typeof setInterval>;\n  ctx.onMountFns.push(() => { id = setInterval(fn, ms); });\n  ctx.onDestroyFns.push(() => clearInterval(id));\n}\n\n/**\n * Schedules a one-shot timeout when the component mounts and cancels it\n * automatically if the component is destroyed before it fires. Client-only.\n *\n * @example\n * useTimeout(() => setVisible(false), 3000);\n */\nexport function useTimeout(fn: () => void, ms: number): void {\n  const ctx = assertInSetup('useTimeout');\n  let id: ReturnType<typeof setTimeout>;\n  ctx.onMountFns.push(() => { id = setTimeout(fn, ms); });\n  ctx.onDestroyFns.push(() => clearTimeout(id));\n}\n","import type { HeadConfig } from './types.js';\nimport { getCurrentSetup } from './context.js';\n\n/** Tracks <meta> and <link> elements injected by each component instance. */\nconst componentHeadElements = new WeakMap<object, Element[]>();\n\n/**\n * SSR: serializes config to HTML tags injected into the stream before </head>.\n * Client: patches document.head — removes old tags, inserts new ones.\n * Call inside component() setup; re-evaluates on every render if values are signal reads.\n */\nexport function useHead(config: HeadConfig): void {\n  const ctx = getCurrentSetup();\n  if (!ctx) {\n    throw new Error('useHead() must be called inside a component setup function.');\n  }\n  ctx.headConfig = config;\n}\n\n/**\n * Apply a HeadConfig to document.head (client-side).\n * Pass a stable key object to track owned elements across re-renders.\n */\nexport function applyHead(config: HeadConfig, owner: object): void {\n  if (typeof document === 'undefined') return;\n\n  // Remove previously injected elements for this owner\n  const prev = componentHeadElements.get(owner) ?? [];\n  for (const el of prev) {\n    el.parentNode?.removeChild(el);\n  }\n  const injected: Element[] = [];\n\n  if (config.title !== undefined) {\n    let titleEl = document.querySelector('title');\n    if (!titleEl) {\n      titleEl = document.createElement('title');\n      document.head.appendChild(titleEl);\n    }\n    titleEl.textContent = config.title;\n  }\n\n  if (config.meta) {\n    for (const attrs of config.meta) {\n      const meta = document.createElement('meta');\n      for (const [k, v] of Object.entries(attrs)) {\n        meta.setAttribute(k, v);\n      }\n      document.head.appendChild(meta);\n      injected.push(meta);\n    }\n  }\n\n  if (config.link) {\n    for (const attrs of config.link) {\n      const link = document.createElement('link');\n      for (const [k, v] of Object.entries(attrs)) {\n        link.setAttribute(k, v);\n      }\n      document.head.appendChild(link);\n      injected.push(link);\n    }\n  }\n\n  componentHeadElements.set(owner, injected);\n}\n\n/**\n * Serialize a HeadConfig to HTML string fragments (for SSR).\n */\nexport function renderHeadToString(config: HeadConfig): string {\n  let out = '';\n\n  if (config.title !== undefined) {\n    out += `<title>${escapeHtml(config.title)}</title>`;\n  }\n\n  if (config.meta) {\n    for (const attrs of config.meta) {\n      const attrStr = Object.entries(attrs)\n        .map(([k, v]) => `${k}=\"${escapeHtml(v)}\"`)\n        .join(' ');\n      out += `<meta ${attrStr}>`;\n    }\n  }\n\n  if (config.link) {\n    for (const attrs of config.link) {\n      const attrStr = Object.entries(attrs)\n        .map(([k, v]) => `${k}=\"${escapeHtml(v)}\"`)\n        .join(' ');\n      out += `<link ${attrStr}>`;\n    }\n  }\n\n  return out;\n}\n\nfunction escapeHtml(str: string): string {\n  return str\n    .replace(/&/g, '&amp;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\"/g, '&quot;');\n}\n","import { signal } from './signal.js';\nimport { h } from './hyperscript.js';\nimport type { Resource, Child } from './types.js';\n\n/**\n * Async data loader — SSR-aware.\n * Client: fires immediately, returns undefined until resolved, triggers re-render on resolve.\n * fn() is re-called when any signal it reads changes.\n */\nexport function resource<T>(fn: () => Promise<T>): Resource<T> {\n  const [value, setValue] = signal<T | undefined>(undefined);\n  const [loading, setLoading] = signal(true);\n  const [error, setError] = signal<Error | undefined>(undefined);\n\n  function load(): void {\n    setLoading(true);\n    setError(undefined);\n    fn().then(\n      (result) => {\n        setValue(result);\n        setLoading(false);\n      },\n      (err: unknown) => {\n        setError(err instanceof Error ? err : new Error(String(err)));\n        setLoading(false);\n      },\n    );\n  }\n\n  // Start loading immediately on client\n  if (typeof document !== 'undefined') {\n    load();\n  }\n\n  const getter = (): T | undefined => value();\n  getter.loading = loading;\n  getter.error = error;\n\n  return getter as Resource<T>;\n}\n\n/**\n * Streaming boundary component.\n * Client: shows fallback while resource is loading, renders children when resolved.\n * SSR: renders fallback (streaming replace happens in hydration layer).\n */\nexport function Suspense(props: { fallback: Child; children: Child }): Element | DocumentFragment {\n  const { fallback, children } = props;\n\n  // We can't know at this point if a resource is loading without inspecting children.\n  // Suspense wraps a container and the component re-renders when resource resolves.\n  const wrapper = document.createElement('div');\n  wrapper.setAttribute('data-suspense', '');\n\n  function renderChild(child: Child): void {\n    while (wrapper.firstChild) wrapper.removeChild(wrapper.firstChild);\n    appendChild(wrapper, child);\n  }\n\n  // Check if any child resource is still loading by looking at resource functions\n  function isLoading(child: Child): boolean {\n    if (typeof child === 'function') {\n      const r = child as Resource<unknown>;\n      if (typeof r.loading === 'function') {\n        return r.loading();\n      }\n    }\n    if (Array.isArray(child)) {\n      return child.some(isLoading);\n    }\n    return false;\n  }\n\n  if (isLoading(children)) {\n    renderChild(fallback);\n  } else {\n    renderChild(children);\n  }\n\n  return wrapper;\n}\n\nfunction appendChild(parent: Element, child: Child): void {\n  if (child === null || child === undefined || child === false) return;\n  if (Array.isArray(child)) {\n    for (const c of child) appendChild(parent, c);\n  } else if (child instanceof Element || child instanceof DocumentFragment) {\n    parent.appendChild(child);\n  } else {\n    parent.appendChild(document.createTextNode(String(child)));\n  }\n}\n","import { h, Fragment } from './hyperscript.js';\nimport type { Child } from './types.js';\n\n// ─── Op types emitted by parseStrings ───────────────────────────────────────\n\ntype AttrOp =\n  | { kind: 'static';  name: string; value: string }  // attr=\"literal\"\n  | { kind: 'bool';    name: string }                  // disabled, checked, …\n  | { kind: 'dynamic'; name: string; idx: number };    // attr=${val}\n\ntype Op =\n  | { t: 'text';  v: string }\n  | { t: 'open';  tag: string; attrs: AttrOp[]; selfClose: boolean }\n  | { t: 'close'; tag: string }\n  | { t: 'val';   idx: number };\n\n// ─── Void elements ───────────────────────────────────────────────────────────\n\nconst VOID = new Set([\n  'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',\n  'link', 'meta', 'param', 'source', 'track', 'wbr',\n]);\n\n// ─── Parse-result cache ──────────────────────────────────────────────────────\n\nconst cache = new WeakMap<TemplateStringsArray, Op[]>();\n\n// ─── Parser ──────────────────────────────────────────────────────────────────\n\nfunction parseStrings(strings: TemplateStringsArray): Op[] {\n  const ops: Op[] = [];\n\n  type State =\n    | 'text'\n    | 'open_tag'\n    | 'attrs'\n    | 'attr_eq'\n    | 'attr_val_sq'\n    | 'attr_val_dq'\n    | 'close_tag';\n\n  let state: State = 'text';\n  let buf = '';\n  let currentTag = '';\n  let pendingAttr = '';\n  let attrs: AttrOp[] = [];\n\n  function flushText(): void {\n    // Keep text as-is if it contains any non-whitespace; skip pure-whitespace indentation\n    if (buf.trim()) ops.push({ t: 'text', v: buf });\n    buf = '';\n  }\n\n  function finalizeOpenTag(selfClose: boolean): void {\n    if (pendingAttr) {\n      attrs.push({ kind: 'bool', name: pendingAttr });\n      pendingAttr = '';\n    } else if (buf.trim()) {\n      attrs.push({ kind: 'bool', name: buf.trim() });\n      buf = '';\n    }\n    const sc = selfClose || VOID.has(currentTag);\n    ops.push({ t: 'open', tag: currentTag, attrs: [...attrs], selfClose: sc });\n    attrs = [];\n    buf = '';\n    state = 'text';\n  }\n\n  for (let ci = 0; ci < strings.length; ci++) {\n    const chunk = strings[ci]!;\n\n    for (let i = 0; i < chunk.length; i++) {\n      const ch = chunk[i]!;\n\n      switch (state) {\n        case 'text': {\n          if (ch === '<') {\n            flushText();\n            // peek: is next char '/'?\n            if (chunk[i + 1 as number] === '/') {\n              state = 'close_tag';\n              i++; // skip /\n            } else {\n              state = 'open_tag';\n              buf = '';\n            }\n          } else {\n            buf += ch;\n          }\n          break;\n        }\n\n        case 'open_tag': {\n          if (ch === ' ' || ch === '\\n' || ch === '\\t' || ch === '\\r') {\n            if (buf.trim()) {\n              currentTag = buf.trim().toLowerCase();\n              attrs = [];\n              buf = '';\n              state = 'attrs';\n            }\n          } else if (ch === '>') {\n            currentTag = buf.trim().toLowerCase();\n            attrs = [];\n            buf = '';\n            finalizeOpenTag(false);\n          } else if (ch === '/' && chunk[i + 1 as number] === '>') {\n            currentTag = buf.trim().toLowerCase();\n            attrs = [];\n            buf = '';\n            i++; // skip >\n            finalizeOpenTag(true);\n          } else {\n            buf += ch;\n          }\n          break;\n        }\n\n        case 'close_tag': {\n          if (ch === '>') {\n            ops.push({ t: 'close', tag: buf.trim().toLowerCase() });\n            buf = '';\n            state = 'text';\n          } else {\n            buf += ch;\n          }\n          break;\n        }\n\n        case 'attrs': {\n          if (ch === '>') {\n            finalizeOpenTag(false);\n          } else if (ch === '/' && chunk[i + 1 as number] === '>') {\n            i++;\n            finalizeOpenTag(true);\n          } else if (ch === '=') {\n            pendingAttr = buf.trim();\n            buf = '';\n            state = 'attr_eq';\n          } else if (ch === ' ' || ch === '\\n' || ch === '\\t' || ch === '\\r') {\n            if (buf.trim()) {\n              attrs.push({ kind: 'bool', name: buf.trim() });\n              buf = '';\n            }\n          } else {\n            buf += ch;\n          }\n          break;\n        }\n\n        case 'attr_eq': {\n          if (ch === '\"') {\n            buf = '';\n            state = 'attr_val_dq';\n          } else if (ch === \"'\") {\n            buf = '';\n            state = 'attr_val_sq';\n          }\n          // dynamic value follows in the values array — handled after chunk loop\n          break;\n        }\n\n        case 'attr_val_dq': {\n          if (ch === '\"') {\n            attrs.push({ kind: 'static', name: pendingAttr, value: buf });\n            pendingAttr = '';\n            buf = '';\n            state = 'attrs';\n          } else {\n            buf += ch;\n          }\n          break;\n        }\n\n        case 'attr_val_sq': {\n          if (ch === \"'\") {\n            attrs.push({ kind: 'static', name: pendingAttr, value: buf });\n            pendingAttr = '';\n            buf = '';\n            state = 'attrs';\n          } else {\n            buf += ch;\n          }\n          break;\n        }\n      }\n    }\n\n    // Place the dynamic value that follows strings[ci]\n    if (ci < strings.length - 1) {\n      if (state === 'text') {\n        flushText();\n        ops.push({ t: 'val', idx: ci });\n      } else if (state === 'attr_eq') {\n        // attr=${val}\n        attrs.push({ kind: 'dynamic', name: pendingAttr, idx: ci });\n        pendingAttr = '';\n        buf = '';\n        state = 'attrs';\n      }\n      // In other states (e.g. inside quoted value) dynamics are uncommon;\n      // they land in 'text' after the tag closes naturally.\n    }\n  }\n\n  if (state === 'text') flushText();\n\n  return ops;\n}\n\n// ─── Builder ─────────────────────────────────────────────────────────────────\n\ninterface Frame {\n  tag: string;\n  props: Record<string, unknown>;\n  children: Child[];\n}\n\nfunction build(ops: Op[], values: unknown[]): Element | DocumentFragment {\n  const stack: Frame[] = [];\n  let current: Frame = { tag: '', props: {}, children: [] };\n\n  for (const op of ops) {\n    switch (op.t) {\n      case 'text': {\n        current.children.push(op.v);\n        break;\n      }\n\n      case 'val': {\n        const v = values[op.idx];\n        if (v === null || v === undefined || v === false) break;\n        if (Array.isArray(v)) {\n          current.children.push(...(v as Child[]));\n        } else {\n          current.children.push(v as Child);\n        }\n        break;\n      }\n\n      case 'open': {\n        const props: Record<string, unknown> = {};\n        for (const a of op.attrs) {\n          if (a.kind === 'static')       props[a.name] = a.value;\n          else if (a.kind === 'bool')    props[a.name] = true;\n          else /* dynamic */             props[a.name] = values[a.idx];\n        }\n\n        if (op.selfClose) {\n          current.children.push(h(op.tag, props) as Element);\n        } else {\n          stack.push(current);\n          current = { tag: op.tag, props, children: [] };\n        }\n        break;\n      }\n\n      case 'close': {\n        const frame = current;\n        current = stack.pop()!;\n        current.children.push(h(frame.tag, frame.props, ...frame.children) as Element);\n        break;\n      }\n    }\n  }\n\n  const kids = current.children;\n  if (kids.length === 1 && kids[0] instanceof Element) return kids[0];\n  return h(Fragment as unknown as (...args: unknown[]) => DocumentFragment, null, ...kids) as DocumentFragment;\n}\n\n// ─── Public API ───────────────────────────────────────────────────────────────\n\n/**\n * html tagged template — JSX-like syntax without a build step.\n *\n * Parses once per call site (WeakMap cache on the stable strings array),\n * then builds DOM via h() on every render. Works in plain <script> tags.\n *\n * @example\n * return () => html`\n *   <section>\n *     <p class=\"count\">${count()}</p>\n *     <button onclick=${increment}>+</button>\n *   </section>\n * `;\n */\nexport function html(\n  strings: TemplateStringsArray,\n  ...values: unknown[]\n): Element | DocumentFragment {\n  let ops = cache.get(strings);\n  if (!ops) {\n    ops = parseStrings(strings);\n    cache.set(strings, ops);\n  }\n  return build(ops, values);\n}\n","/**\n * Registry mapping component containers → their onDestroy callbacks.\n *\n * Kept in a separate module so that both component.ts (writer) and diff.ts\n * (reader) can import it without creating a circular dependency.\n */\nexport const componentDestroyRegistry = new WeakMap<Element, Array<() => void>>();\n","import { elListeners } from './listeners.js';\nimport { componentDestroyRegistry } from './component-registry.js';\n\n/**\n * Walk a subtree and call onDestroy callbacks for any component containers\n * found within it. Called before a node is removed or replaced in the DOM.\n */\nfunction destroyComponentTree(node: Node): void {\n  if (node.nodeType !== Node.ELEMENT_NODE) return;\n  const el = node as Element;\n  const fns = componentDestroyRegistry.get(el);\n  if (fns) {\n    for (const fn of fns) fn();\n    componentDestroyRegistry.delete(el);\n  }\n  for (const child of Array.from(el.childNodes)) {\n    destroyComponentTree(child);\n  }\n}\n\n/**\n * Reconcile DOM children of `parent` against `newContent`.\n * - Element: compare parent.childNodes against [newContent]\n * - DocumentFragment: compare parent.childNodes against newContent.childNodes\n * Only mutates nodes that actually differ — identical subtrees = zero DOM ops.\n */\nexport function reconcileChildren(\n  parent: Element,\n  newContent: Element | DocumentFragment | void\n): void {\n  if (!newContent) return;\n\n  const newNodes: Node[] = newContent instanceof DocumentFragment\n    ? Array.from(newContent.childNodes)\n    : [newContent];\n\n  const oldNodes = Array.from(parent.childNodes);\n  const maxLen = Math.max(oldNodes.length, newNodes.length);\n\n  for (let i = 0; i < maxLen; i++) {\n    const oldNode = oldNodes[i];\n    const newNode = newNodes[i];\n\n    if (oldNode === undefined && newNode !== undefined) {\n      parent.appendChild(newNode); // move directly — preserves event listeners\n    } else if (oldNode !== undefined && newNode === undefined) {\n      destroyComponentTree(oldNode);\n      parent.removeChild(oldNode);\n    } else if (oldNode !== undefined && newNode !== undefined) {\n      patchNode(parent, oldNode, newNode);\n    }\n  }\n}\n\nfunction patchNode(parent: Node, oldNode: ChildNode, newNode: Node): void {\n  // Text nodes\n  if (oldNode.nodeType === Node.TEXT_NODE && newNode.nodeType === Node.TEXT_NODE) {\n    if (oldNode.textContent !== newNode.textContent) {\n      oldNode.textContent = newNode.textContent;\n    }\n    return;\n  }\n\n  // Same element tag — patch attributes and recurse children\n  if (\n    oldNode.nodeType === Node.ELEMENT_NODE &&\n    newNode.nodeType === Node.ELEMENT_NODE &&\n    (oldNode as Element).tagName === (newNode as Element).tagName\n  ) {\n    reconcileAttributes(oldNode as Element, newNode as Element);\n    reconcileChildNodes(oldNode as Element, newNode as Element);\n    return;\n  }\n\n  // Different type or tag — destroy any components in the old subtree, then replace\n  destroyComponentTree(oldNode);\n  parent.replaceChild(newNode, oldNode);\n}\n\nfunction reconcileAttributes(oldEl: Element, newEl: Element): void {\n  // Remove attributes not in new\n  for (const attr of Array.from(oldEl.attributes)) {\n    if (!newEl.hasAttribute(attr.name)) {\n      oldEl.removeAttribute(attr.name);\n    }\n  }\n  // Set new/changed attributes\n  for (const attr of Array.from(newEl.attributes)) {\n    if (oldEl.getAttribute(attr.name) !== attr.value) {\n      oldEl.setAttribute(attr.name, attr.value);\n    }\n  }\n  // Reconcile JS event listeners (set via addEventListener, invisible to .attributes)\n  const oldListeners = elListeners.get(oldEl);\n  const newListeners = elListeners.get(newEl);\n  if (newListeners) {\n    const updated = new Map<string, EventListenerOrEventListenerObject>();\n    for (const [event, handler] of newListeners) {\n      const prev = oldListeners?.get(event);\n      if (prev !== handler) {\n        if (prev !== undefined) oldEl.removeEventListener(event, prev);\n        oldEl.addEventListener(event, handler);\n      }\n      updated.set(event, handler);\n    }\n    // Remove listeners that no longer exist\n    if (oldListeners) {\n      for (const [event, handler] of oldListeners) {\n        if (!newListeners.has(event)) oldEl.removeEventListener(event, handler);\n      }\n    }\n    elListeners.set(oldEl, updated);\n  } else if (oldListeners) {\n    // New element has no listeners — remove all old ones\n    for (const [event, handler] of oldListeners) {\n      oldEl.removeEventListener(event, handler);\n    }\n    elListeners.delete(oldEl);\n  }\n}\n\nfunction reconcileChildNodes(oldEl: Element, newEl: Element): void {\n  const oldChildren = Array.from(oldEl.childNodes);\n  const newChildren = Array.from(newEl.childNodes);\n  const maxLen = Math.max(oldChildren.length, newChildren.length);\n\n  for (let i = 0; i < maxLen; i++) {\n    const oldChild = oldChildren[i];\n    const newChild = newChildren[i];\n\n    if (!oldChild && newChild) {\n      oldEl.appendChild(newChild); // move directly — preserves event listeners\n    } else if (oldChild && !newChild) {\n      destroyComponentTree(oldChild);\n      oldEl.removeChild(oldChild);\n    } else if (oldChild && newChild) {\n      patchNode(oldEl, oldChild, newChild);\n    }\n  }\n}\n","/**\n * Wraps a render function in a microtask scheduler.\n * Multiple signal updates in one tick → exactly 1 re-render via queueMicrotask.\n */\nexport function makeScheduler(renderFn: () => void): () => void {\n  let pending = false;\n\n  return function scheduleRerender(): void {\n    if (pending) return;\n    pending = true;\n    queueMicrotask(() => {\n      pending = false;\n      renderFn();\n    });\n  };\n}\n","import { setCurrentObserver, getCurrentObserver } from './signal.js';\nimport { setCurrentSetup, createSetupContext } from './context.js';\nimport { applyHead, renderHeadToString } from './head.js';\nimport { reconcileChildren } from './diff.js';\nimport { makeScheduler } from './scheduler.js';\nimport { isSSRMode, setSSRHeadOutput } from './ssr-context.js';\nimport type { ComponentOptions, ComponentProps, RenderFn } from './types.js';\nimport type { Effect } from './types.js';\nimport { componentDestroyRegistry } from './component-registry.js';\n\n/** Symbol key used to attach onDestroyFns to a component container. */\nexport const DESTROY_KEY: unique symbol = Symbol('actjs.destroy');\n\n/**\n * Define a stateful component.\n * setup() runs ONCE — call signal(), onInit(), onMount(), onDestroy(), useHead() here.\n * setup() returns a render fn that re-runs when any subscribed signal changes.\n * options.hydrate controls island strategy (default: 'static').\n *\n * @example\n * const Counter = component(() => {\n *   const [count, setCount] = signal(0);\n *   return () => (\n *     <button onClick={() => setCount(n => n + 1)}>\n *       Clicked {count()} times\n *     </button>\n *   );\n * }, { hydrate: 'interactive' });\n */\nexport function component<P extends object = object>(\n  setup: (props: P & ComponentProps<P>) => RenderFn,\n  options: ComponentOptions = {},\n): (props?: P & ComponentProps<P>) => Element {\n  const hydrateStrategy = options.hydrate ?? 'static';\n\n  return function mountComponent(props?: P & ComponentProps<P>): Element {\n    const mergedProps = (props ?? {}) as P & ComponentProps<P>;\n\n    // Container element for this component instance\n    const container = document.createElement('div');\n    container.setAttribute('data-component', '');\n    if (hydrateStrategy !== 'static') {\n      container.setAttribute('data-hydrate', hydrateStrategy);\n    }\n\n    // Stable owner object for head tracking\n    const owner: object = {};\n\n    // Run setup inside the context\n    const ctx = createSetupContext();\n    setCurrentSetup(ctx);\n    let renderFn: RenderFn;\n    try {\n      renderFn = setup(mergedProps);\n    } finally {\n      setCurrentSetup(null);\n    }\n\n    // Attach destroy fns so app.ts can clean up\n    (container as unknown as Record<symbol, Array<() => void>>)[DESTROY_KEY] = ctx.onDestroyFns;\n    // Register in shared registry so the DOM reconciler can call destroy when removing\n    componentDestroyRegistry.set(container, ctx.onDestroyFns);\n\n    // The Effect that re-runs render when signals change\n    const renderEffect: Effect = {\n      deps: new Set(),\n      run: () => scheduleRerender(),\n    };\n\n    function doRender(): void {\n      // Clean up previous signal subscriptions\n      for (const dep of renderEffect.deps) {\n        dep.delete(renderEffect);\n      }\n      renderEffect.deps.clear();\n\n      // Run render fn in tracking context\n      const prev = getCurrentObserver();\n      setCurrentObserver(renderEffect);\n      let result: ReturnType<RenderFn>;\n      try {\n        result = renderFn();\n      } catch (err) {\n        console.error('[actjs] render error:', err);\n        throw err;\n      } finally {\n        setCurrentObserver(prev);\n      }\n\n      // Apply head config\n      if (ctx.headConfig) {\n        if (isSSRMode()) {\n          // SSR: capture head as HTML string for renderToString to read\n          setSSRHeadOutput(renderHeadToString(ctx.headConfig));\n        } else {\n          applyHead(ctx.headConfig, owner);\n        }\n      }\n\n      // Diff into container\n      reconcileChildren(container, result ?? undefined);\n    }\n\n    const scheduleRerender = makeScheduler(doRender);\n\n    function initAndMount(): void {\n      doRender();\n      // Run onInit (server + client) — log errors to console so they're never silently swallowed\n      Promise.all(ctx.onInitFns.map((fn) => fn())).catch((err) => {\n        console.error('[actjs] onInit error:', err);\n      });\n      // Run onMount (client only — skip during SSR)\n      if (!isSSRMode()) {\n        queueMicrotask(() => {\n          for (const fn of ctx.onMountFns) fn();\n        });\n      }\n    }\n\n    if (hydrateStrategy === 'static') {\n      initAndMount();\n    } else if (hydrateStrategy === 'interactive') {\n      initAndMount();\n    } else if (hydrateStrategy === 'visible') {\n      if (typeof IntersectionObserver !== 'undefined') {\n        const observer = new IntersectionObserver((entries) => {\n          for (const entry of entries) {\n            if (entry.isIntersecting) {\n              observer.disconnect();\n              initAndMount();\n            }\n          }\n        });\n        observer.observe(container);\n      } else {\n        initAndMount();\n      }\n    }\n\n    return container;\n  };\n}\n\nexport { component as defineComponent };\n","/**\n * Injects a <style> or <link> into <head> and tracks it for cleanup.\n * All elements injected via a single CssManager instance are removed on destroy().\n */\nexport class CssManager {\n  private readonly injected: Element[] = [];\n\n  criticalCSS(css: string): void {\n    if (typeof document === 'undefined') return;\n    const style = document.createElement('style');\n    style.textContent = css;\n    document.head.appendChild(style);\n    this.injected.push(style);\n  }\n\n  criticalStylesheet(href: string): void {\n    if (typeof document === 'undefined') return;\n    const link = document.createElement('link');\n    link.setAttribute('rel', 'stylesheet');\n    link.setAttribute('href', href);\n    document.head.appendChild(link);\n    this.injected.push(link);\n  }\n\n  destroy(): void {\n    for (const el of this.injected) {\n      el.parentNode?.removeChild(el);\n    }\n    this.injected.length = 0;\n  }\n}\n","/**\n * Safe timer wrappers — auto-cleared on destroy().\n */\nexport class TimerManager {\n  private readonly intervals = new Set<ReturnType<typeof setInterval>>();\n  private readonly timeouts = new Set<ReturnType<typeof setTimeout>>();\n\n  safeSetInterval(fn: () => void, ms: number): ReturnType<typeof setInterval> {\n    const id = setInterval(fn, ms);\n    this.intervals.add(id);\n    return id;\n  }\n\n  safeClearInterval(id: ReturnType<typeof setInterval>): void {\n    clearInterval(id);\n    this.intervals.delete(id);\n  }\n\n  safeSetTimeout(fn: () => void, ms: number): ReturnType<typeof setTimeout> {\n    const id = setTimeout(() => {\n      this.timeouts.delete(id);\n      fn();\n    }, ms);\n    this.timeouts.add(id);\n    return id;\n  }\n\n  safeClearTimeout(id: ReturnType<typeof setTimeout>): void {\n    clearTimeout(id);\n    this.timeouts.delete(id);\n  }\n\n  destroy(): void {\n    for (const id of this.intervals) clearInterval(id);\n    for (const id of this.timeouts) clearTimeout(id);\n    this.intervals.clear();\n    this.timeouts.clear();\n  }\n}\n","import { CssManager } from './css.js';\nimport { TimerManager } from './timers.js';\nimport { reconcileChildren } from './diff.js';\nimport { DESTROY_KEY } from './component.js';\nimport type { ActApp, CreateAppOptions, Props } from './types.js';\n\n/**\n * Central app factory. Resolves container, mounts root component,\n * and provides cleanup on destroy().\n * Lifecycle hooks (onInit/onMount/onDestroy) are run by component() itself.\n *\n * @example\n * const app = createApp('#root').mount(MyComponent);\n *\n * // With hydration (SSR rehydration — reconciles instead of replacing):\n * createApp('#root', { hydrate: true }).mount(MyComponent);\n *\n * // Cleanup all timers, CSS, and onDestroy hooks:\n * app.destroy();\n */\nexport function createApp(\n  container: string | Element,\n  options: CreateAppOptions = {},\n): ActApp {\n  const { hydrate = false, devWarnings = true } = options;\n\n  const root: Element =\n    typeof container === 'string'\n      ? (document.querySelector(container) as Element)\n      : container;\n\n  if (!root && devWarnings) {\n    console.warn(`actjs: createApp() — container \"${String(container)}\" not found.`);\n  }\n\n  const css = new CssManager();\n  const timers = new TimerManager();\n\n  let mountedEl: Element | null = null;\n\n  return {\n    mount(componentFn: (props?: Props) => Element | void): void {\n      const renderedEl = componentFn();\n      mountedEl = renderedEl ?? null;\n\n      if (renderedEl) {\n        if (hydrate) {\n          reconcileChildren(root, renderedEl);\n        } else {\n          while (root.firstChild) root.removeChild(root.firstChild);\n          root.appendChild(renderedEl);\n        }\n      }\n    },\n\n    destroy(): void {\n      // Call onDestroyFns attached to the mounted element by component()\n      if (mountedEl) {\n        const destroyFns = (mountedEl as unknown as Record<symbol, Array<() => void>>)[DESTROY_KEY];\n        if (destroyFns) {\n          for (const fn of destroyFns) fn();\n        }\n      }\n      css.destroy();\n      timers.destroy();\n    },\n\n    criticalCSS(cssStr: string): void {\n      css.criticalCSS(cssStr);\n    },\n\n    criticalStylesheet(href: string): void {\n      css.criticalStylesheet(href);\n    },\n\n    safeSetInterval(fn: () => void, ms: number): number {\n      return timers.safeSetInterval(fn, ms) as unknown as number;\n    },\n\n    safeClearInterval(id: number): void {\n      timers.safeClearInterval(id as unknown as ReturnType<typeof setInterval>);\n    },\n\n    safeSetTimeout(fn: () => void, ms: number): number {\n      return timers.safeSetTimeout(fn, ms) as unknown as number;\n    },\n\n    safeClearTimeout(id: number): void {\n      timers.safeClearTimeout(id as unknown as ReturnType<typeof setTimeout>);\n    },\n  };\n}\n","import { signal, computed } from './signal.js';\nimport { component } from './component.js';\nimport { h } from './hyperscript.js';\nimport type { Child, Route, RouterOptions } from './types.js';\n\n// ─── Module-level router state ────────────────────────────────────────────────\n\nconst safePathname = (): string =>\n  /* c8 ignore next */\n  typeof location !== 'undefined' ? location.pathname : '/';\n\nconst safeSearch = (): string =>\n  /* c8 ignore next */\n  typeof location !== 'undefined' ? location.search : '';\n\nconst [_path, _setPath] = signal(safePathname());\nconst [_search, _setSearch] = signal(safeSearch());\n\n/** List of routes set by the most recent createRouter() call. */\nlet _activeRoutes: Route[] = [];\nlet _base = '';\n\n// ─── Route matching ───────────────────────────────────────────────────────────\n\n/**\n * Match a route pattern against a pathname.\n * Returns extracted params if matched, null if not.\n * Supports `:param` segments and `*` wildcard.\n */\nexport function matchRoute(\n  pattern: string,\n  pathname: string,\n): Record<string, string> | null {\n  if (pattern === '*') return {};\n\n  const keys: string[] = [];\n  const regexStr = pattern.replace(/:([^/]+)/g, (_: string, key: string) => {\n    keys.push(key);\n    return '([^/]+)';\n  });\n\n  const regex = new RegExp(`^${regexStr}$`);\n  const m = pathname.match(regex);\n  if (!m) return null;\n\n  const paramResult: Record<string, string> = {};\n  keys.forEach((k, i) => {\n    /* c8 ignore next */\n    paramResult[k] = decodeURIComponent(m[i + 1] ?? '');\n  });\n  return paramResult;\n}\n\nfunction normalize(path: string): string {\n  if (!_base) return path;\n  return path.startsWith(_base) ? path.slice(_base.length) || '/' : path;\n}\n\nfunction findMatch(\n  path: string,\n): { route: Route; params: Record<string, string> } | null {\n  const normalized = normalize(path);\n  for (const route of _activeRoutes) {\n    const p = matchRoute(route.path, normalized);\n    if (p !== null) return { route, params: p };\n  }\n  return null;\n}\n\n// ─── Public reactive getters ──────────────────────────────────────────────────\n\n/** Reactive getter for the current pathname. Subscribes caller to path changes. */\nexport const currentPath: () => string = _path;\n\n/**\n * Reactive getter for current route params.\n * Reading params() inside a component render auto-subscribes to route changes.\n */\nexport const params: () => Record<string, string> = computed(() => {\n  const path = _path(); // track\n  return findMatch(path)?.params ?? {};\n});\n\n/**\n * Reactive getter for current URL query string as a key-value map.\n * Reading query() inside a component render auto-subscribes to route changes.\n */\nexport const query: () => Record<string, string> = computed(() => {\n  const search = _search(); // track — re-evaluates when navigate() updates search\n  const queryResult: Record<string, string> = {};\n  new URLSearchParams(search).forEach((v, k) => {\n    queryResult[k] = v;\n  });\n  return queryResult;\n});\n\n// ─── Navigation ───────────────────────────────────────────────────────────────\n\n/**\n * Programmatic navigation. Pushes to browser history and updates path signal.\n * No-op during SSR.\n */\nexport function navigate(to: string): void {\n  /* c8 ignore next */\n  if (typeof history === 'undefined') return;\n  history.pushState(null, '', to);\n  const qIdx = to.indexOf('?');\n  const pathname = qIdx !== -1 ? to.slice(0, qIdx) : to;\n  const search = qIdx !== -1 ? to.slice(qIdx) : '';\n  _setPath(pathname);\n  _setSearch(search);\n}\n\n// Sync signal on browser back/forward\nif (typeof window !== 'undefined') {\n  window.addEventListener('popstate', () => {\n    _setPath(location.pathname);\n    _setSearch(location.search);\n  });\n}\n\n// ─── Link component ───────────────────────────────────────────────────────────\n\n/**\n * Declarative navigation link. Renders an <a> that calls navigate() on click.\n * Prevents full page reload.\n * Props: href (required), class?, and any other valid <a> attributes.\n */\nexport function Link(props: Record<string, unknown>): Element {\n  const { href, children, ...rest } = props;\n  const childrenArr: Child[] = Array.isArray(children)\n    ? (children as Child[])\n    : children !== undefined\n      ? [children as Child]\n      : [];\n\n  return h(\n    'a',\n    {\n      ...rest,\n      href,\n      onclick: (e: Event) => {\n        e.preventDefault();\n        navigate(href as string);\n      },\n    },\n    ...childrenArr,\n  ) as Element;\n}\n\n// ─── Router factory ───────────────────────────────────────────────────────────\n\n/**\n * Create a router component from a list of routes.\n * Returns a component factory compatible with createApp().mount().\n *\n * Routes are matched top-to-bottom. Use `*` as the last route for 404.\n *\n * @example\n * const App = createRouter([\n *   { path: '/',           component: Home },\n *   { path: '/blog/:slug', component: BlogPost },\n *   { path: '*',           component: NotFound },\n * ]);\n * createApp('#root').mount(App);\n */\nexport function createRouter(\n  routes: Route[],\n  options: RouterOptions = {},\n): () => Element {\n  _activeRoutes = routes;\n  _base = options.base ?? '';\n\n  const RouterComponent = component(\n    () => {\n      return (): Element => {\n        const path = _path(); // subscribe — re-renders when navigate() fires\n        const normalized = normalize(path);\n\n        for (const route of routes) {\n          const extractedParams = matchRoute(route.path, normalized);\n          if (extractedParams !== null) {\n            return route.component({ params: extractedParams });\n          }\n        }\n\n        // No match — warn in dev and return empty div (user should add a '*' catch-all)\n        console.warn(`[actjs] router: no route matched \"${normalized}\" — add a { path: '*', component: NotFound } catch-all.`);\n        return document.createElement('div');\n      };\n    },\n    { hydrate: 'interactive' },\n  );\n\n  return RouterComponent;\n}\n","// ─── Runtime CDN loader ────────────────────────────────────────────────────────\n// Loads external packages (scripts, stylesheets) from CDN at runtime.\n// All functions are SSR-safe and idempotent — the same URL will never be\n// injected twice even with concurrent callers.\n\nimport type { LoadScriptOptions, LoadStylesheetOptions } from './types.js';\nimport type { ActDepsConfig } from './deps.js';\nimport { resolveUrl, resolveStylesheetUrl } from './deps.js';\n\n// Module-level dedup cache — intentionally NOT per-instance. CDN resources\n// (lodash, bootstrap) should load once per page, not once per createApp() call.\nconst loadedUrls = new Set<string>();\nconst pendingLoads = new Map<string, Promise<void>>();\n\n/**\n * Dynamically inject a <script> tag and resolve when loaded.\n * Subsequent calls with the same URL return immediately (idempotent).\n * No-ops on the server (SSR).\n *\n * @example\n * await loadScript('https://cdn.jsdelivr.net/npm/canvas-confetti@1.9.3/dist/confetti.browser.min.js');\n * window.confetti({ particleCount: 150, spread: 70 });\n */\nexport function loadScript(url: string, opts?: LoadScriptOptions): Promise<void> {\n  if (typeof document === 'undefined') return Promise.resolve();\n  if (loadedUrls.has(url)) return Promise.resolve();\n  const inflight = pendingLoads.get(url);\n  if (inflight) return inflight;\n  if (document.querySelector(`script[src=\"${url}\"]`)) {\n    loadedUrls.add(url);\n    return Promise.resolve();\n  }\n  const promise = new Promise<void>((resolve, reject) => {\n    const script = document.createElement('script');\n    script.src = url;\n    if (opts?.type) script.type = opts.type;\n    if (opts?.async !== undefined) script.async = opts.async;\n    if (opts?.defer) script.defer = opts.defer;\n    if (opts?.crossOrigin) script.crossOrigin = opts.crossOrigin;\n    if (opts?.integrity) script.integrity = opts.integrity;\n    if (opts?.noModule) (script as HTMLScriptElement).noModule = opts.noModule;\n    if (opts?.id) script.id = opts.id;\n    script.onload = () => {\n      loadedUrls.add(url);\n      pendingLoads.delete(url);\n      resolve();\n    };\n    script.onerror = () => {\n      pendingLoads.delete(url);\n      reject(new Error(`actjs: Failed to load script: ${url}`));\n    };\n    document.head.appendChild(script);\n  });\n  pendingLoads.set(url, promise);\n  return promise;\n}\n\n/**\n * Dynamically inject a <link rel=\"stylesheet\"> and resolve when loaded.\n * Subsequent calls with the same href return immediately (idempotent).\n * No-ops on the server (SSR).\n *\n * @example\n * await loadStylesheet('https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css');\n */\nexport function loadStylesheet(href: string, opts?: LoadStylesheetOptions): Promise<void> {\n  if (typeof document === 'undefined') return Promise.resolve();\n  if (loadedUrls.has(href)) return Promise.resolve();\n  const inflight = pendingLoads.get(href);\n  if (inflight) return inflight;\n  if (document.querySelector(`link[rel=\"stylesheet\"][href=\"${href}\"]`)) {\n    loadedUrls.add(href);\n    return Promise.resolve();\n  }\n  const promise = new Promise<void>((resolve, reject) => {\n    const link = document.createElement('link');\n    link.rel = 'stylesheet';\n    link.href = href;\n    if (opts?.media) link.media = opts.media;\n    if (opts?.crossOrigin) link.crossOrigin = opts.crossOrigin;\n    if (opts?.integrity) link.integrity = opts.integrity;\n    link.onload = () => {\n      loadedUrls.add(href);\n      pendingLoads.delete(href);\n      resolve();\n    };\n    link.onerror = () => {\n      pendingLoads.delete(href);\n      reject(new Error(`actjs: Failed to load stylesheet: ${href}`));\n    };\n    document.head.appendChild(link);\n  });\n  pendingLoads.set(href, promise);\n  return promise;\n}\n\n/**\n * Inject a <script type=\"importmap\"> so bare CDN imports resolve in the browser.\n * Must be called before any ES module scripts that use bare specifiers.\n * No-ops if an import map already exists or on the server (SSR).\n *\n * @example\n * defineImportMap({ lodash: 'https://esm.sh/lodash@4.17.21' })\n * // then: import _ from 'lodash' works in <script type=\"module\">\n */\nexport function defineImportMap(map: Record<string, string>): void {\n  if (typeof document === 'undefined') return;\n  if (document.querySelector('script[type=\"importmap\"]')) {\n    console.warn('actjs: An import map already exists. defineImportMap() had no effect.');\n    return;\n  }\n  const script = document.createElement('script');\n  script.type = 'importmap';\n  script.textContent = JSON.stringify({ imports: map }, null, 2);\n  document.head.insertBefore(script, document.head.firstChild);\n}\n\n/**\n * Inject a <link rel=\"preload\"> hint to let the browser prefetch a resource.\n * No-ops on the server (SSR).\n */\nexport function preloadResource(href: string, as: 'script' | 'style' | 'font'): void {\n  if (typeof document === 'undefined') return;\n  const link = document.createElement('link');\n  link.rel = 'preload';\n  link.href = href;\n  link.as = as;\n  document.head.appendChild(link);\n}\n\n/**\n * Load all packages declared in an actjs deps config.\n * Injects an import map for JS packages and stylesheet links for CSS packages.\n * Intended for IIFE / no-bundler usage. Vite users get this automatically\n * via the actjsPlugin() Vite plugin at build time.\n *\n * @example\n * await useDeps({ provider: 'esm.sh', packages: { lodash: '4.17.21' } })\n */\nexport async function useDeps(config: ActDepsConfig): Promise<void> {\n  if (typeof document === 'undefined') return;\n  const { provider = 'esm.sh', packages } = config;\n  const importMap: Record<string, string> = {};\n  const stylesheetLoads: Promise<void>[] = [];\n\n  for (const [pkg, version] of Object.entries(packages)) {\n    const cssUrl = resolveStylesheetUrl(pkg, version);\n    if (cssUrl) {\n      stylesheetLoads.push(loadStylesheet(cssUrl));\n    }\n    importMap[pkg] = resolveUrl(pkg, version, provider);\n  }\n\n  defineImportMap(importMap);\n  await Promise.all(stylesheetLoads);\n}\n\n/** @internal Reset module-level cache between tests. */\nexport function __resetLoaderState(): void {\n  loadedUrls.clear();\n  pendingLoads.clear();\n}\n"],"names":["currentObserver","batchDepth","pendingEffects","batch","fn","toRun","eff","setCurrentObserver","observer","getCurrentObserver","signal","initialValue","options","value","subscribers","equalsFn","_a","newValue","next","effect","computed","cachedValue","dirty","dep","sub","computedSubscribers","prev","registry","globalSignal","key","currentSetup","getCurrentSetup","setCurrentSetup","ctx","createSetupContext","assertInSetup","hookName","onInit","onMount","onDestroy","cleanup","running","dispose","useInterval","ms","id","useTimeout","componentHeadElements","useHead","config","applyHead","owner","el","_b","injected","titleEl","attrs","meta","k","v","link","renderHeadToString","out","escapeHtml","attrStr","str","resource","setValue","loading","setLoading","error","setError","load","result","err","getter","Suspense","props","fallback","children","wrapper","renderChild","child","appendChild","isLoading","r","parent","c","VOID","cache","parseStrings","strings","ops","state","buf","currentTag","pendingAttr","flushText","finalizeOpenTag","selfClose","sc","ci","chunk","i","ch","build","values","stack","current","op","a","h","frame","kids","Fragment","html","componentDestroyRegistry","destroyComponentTree","node","fns","reconcileChildren","newContent","newNodes","oldNodes","maxLen","oldNode","newNode","patchNode","reconcileAttributes","reconcileChildNodes","oldEl","newEl","attr","oldListeners","elListeners","newListeners","updated","event","handler","oldChildren","newChildren","oldChild","newChild","makeScheduler","renderFn","pending","DESTROY_KEY","component","setup","hydrateStrategy","mergedProps","container","renderEffect","scheduleRerender","doRender","isSSRMode","setSSRHeadOutput","initAndMount","entries","entry","CssManager","css","style","href","TimerManager","createApp","hydrate","devWarnings","root","timers","mountedEl","componentFn","renderedEl","destroyFns","cssStr","safePathname","safeSearch","_path","_setPath","_search","_setSearch","_activeRoutes","_base","matchRoute","pattern","pathname","keys","regexStr","_","regex","m","paramResult","normalize","path","findMatch","normalized","route","p","currentPath","params","query","search","queryResult","navigate","to","qIdx","Link","rest","childrenArr","e","createRouter","routes","extractedParams","loadedUrls","pendingLoads","loadScript","url","opts","inflight","promise","resolve","reject","script","loadStylesheet","defineImportMap","map","preloadResource","as","useDeps","provider","packages","importMap","stylesheetLoads","pkg","version","cssUrl","resolveStylesheetUrl","resolveUrl"],"mappings":"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"}